//   Copyright 2012,2013 Vaughn Vernon
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package com.saasovation.common;

/**
 * 断言关注
 * 描述：必须经过继承才可访问里面的方法
 */
public class AssertionConcern {
    /**
     * 子类访问用构造器
     */
    protected AssertionConcern() {
        // 执行Object
        super();
    }

    /**
     * 断言参数是否相等
     * @param anObject1 对象1
     * @param anObject2 对象2
     * @param aMessage  错误信息
     */
    protected void assertArgumentEquals(Object anObject1, Object anObject2, String aMessage) {
        // 如果两个对象不相同，则会抛出非法参数异常
        if (!anObject1.equals(anObject2)) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 断言参数为假
     * @param aBoolean 参数
     * @param aMessage 错误信息
     */
    protected void assertArgumentFalse(boolean aBoolean, String aMessage) {
        // 如果参数为真，则会抛出非法参数异常
        if (aBoolean) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 断言参数长度
     * @param aString 字符串
     * @param aMaximum 最大长度
     * @param aMessage 错误信息
     */
    protected void assertArgumentLength(String aString, int aMaximum, String aMessage) {
        // 把字符串去掉两侧空格后，获取长度
        int length = aString.trim().length();
        // 如果字符串长度 大于最大长度，则会抛出非法参数异常
        if (length > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 断言参数长度
     * @param aString   字符串
     * @param aMinimum  最短长度
     * @param aMaximum  最大长度
     * @param aMessage  错误信息
     */
    protected void assertArgumentLength(String aString, int aMinimum, int aMaximum, String aMessage) {
        // 把字符串去掉两侧空格后，获取长度
        int length = aString.trim().length();
        // 如果字符串长度 大于最大长度 或者 小于最短长度，则会抛出非法参数异常
        if (length < aMinimum || length > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 断言参数不为空
     * @param aString 字符串
     * @param aMessage 错误信息
     */
    protected void assertArgumentNotEmpty(String aString, String aMessage) {
        // 如果字符串为空 或者 字符串去掉两侧空格后 判断是空，则会抛出非法参数异常
        if (aString == null || aString.trim().isEmpty()) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 断言参数不相等
     * @param anObject1 对象1
     * @param anObject2 对象2
     * @param aMessage  错误信息
     */
    protected void assertArgumentNotEquals(Object anObject1, Object anObject2, String aMessage) {
        // 如果两个对象相等，则会抛出非法参数异常
        if (anObject1.equals(anObject2)) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 断言参数不是无效的
     * @param anObject 对象
     * @param aMessage 错误信息
     */
    protected void assertArgumentNotNull(Object anObject, String aMessage) {
        // 如果对象为空，则会抛出非法参数异常
        if (anObject == null) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 断言参数范围（双精度数据）
     * @param aValue    双精度值
     * @param aMinimum  最小双精度值
     * @param aMaximum  最大双精度值
     * @param aMessage  错误信息
     */
    protected void assertArgumentRange(double aValue, double aMinimum, double aMaximum, String aMessage) {
        // 如果 双精度值 小于 最小双精度值 或者 大于 最大双精度值，则会抛出非法参数异常
        if (aValue < aMinimum || aValue > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }
    /**
     * 断言参数范围（单精度数据）
     * @param aValue    单精度值
     * @param aMinimum  最小单精度值
     * @param aMaximum  最大单精度值
     * @param aMessage  错误信息
     */
    protected void assertArgumentRange(float aValue, float aMinimum, float aMaximum, String aMessage) {
        // 如果 单精度值 小于 最小单精度值 或者 大于 最大单精度值，则会抛出非法参数异常
        if (aValue < aMinimum || aValue > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }
    /**
     * 断言参数范围（整型数据）
     * @param aValue    整型值
     * @param aMinimum  最小整型值
     * @param aMaximum  最大整型值
     * @param aMessage  错误信息
     */
    protected void assertArgumentRange(int aValue, int aMinimum, int aMaximum, String aMessage) {
        // 如果 整型值 小于 最小整型值 或者 大于 最大整型值，则会抛出非法参数异常
        if (aValue < aMinimum || aValue > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }
    /**
     * 断言参数范围（长整型数据）
     * @param aValue    长整型值
     * @param aMinimum  最小长整型值
     * @param aMaximum  最大长整型值
     * @param aMessage  错误信息
     */
    protected void assertArgumentRange(long aValue, long aMinimum, long aMaximum, String aMessage) {
        // 如果 长整型值 小于 最小长整型值 或者 大于 最大长整型值，则会抛出非法参数异常
        if (aValue < aMinimum || aValue > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }
    /**
     * 断言参数为真
     * @param aBoolean 参数
     * @param aMessage 错误信息
     */
    protected void assertArgumentTrue(boolean aBoolean, String aMessage) {
        // 如果参数为假，则会抛出非法参数异常
        if (!aBoolean) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 断言状态为假
     * @param aBoolean 状态值
     * @param aMessage 错误信息
     */
    protected void assertStateFalse(boolean aBoolean, String aMessage) {
        // 如果状态值为真，则会抛出非法参数异常
        if (aBoolean) {
            throw new IllegalStateException(aMessage);
        }
    }

    /**
     * 断言状态为真
     * @param aBoolean 状态值
     * @param aMessage 错误信息
     */
    protected void assertStateTrue(boolean aBoolean, String aMessage) {
        // 如果状态值为假，则会抛出非法参数异常
        if (!aBoolean) {
            throw new IllegalStateException(aMessage);
        }
    }
}
